package path.calculator;

import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;

public class PathCalculator<T extends Comparable<T>> {
    Set<T> nodes = new HashSet<T>();
    HashMap<T, LinkedList<T>> pathFromTo = new HashMap<T, LinkedList<T>>();

    public int totalPaths() {
        PermutationGenerator<T> generator = new PermutationGenerator<T>();
        generator.addAll(nodes);
        List<Permutation<T>> allPermutations = generator.allCombinations();
        List<Permutation<T>> validPermutations = new LinkedList<Permutation<T>>();
        for (Permutation<T> current : allPermutations)
            if (isValidPermutation(current))
                validPermutations.add(current);

        return validPermutations.size();
    }

    private boolean isValidPermutation(Permutation<T> current) {
        for(int i = 0; i < current.length() -1 ; ++i)
            for(int j = i + 1; j < current.length(); ++j)
                if(pathFromTo.containsKey(current.get(j)) && pathFromTo.get(current.get(j)).contains(current.get(i))
                        return false;
                
                return true;
    }

    public void addNode(T nodeName) {
        nodes.add(nodeName);
    }

    public void mustFlowFromNodeToNode(T previous, T latter) {
        pathFromTo.put(previous, latter);
    }
}
